home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / C / Utilities / Mac⁄gnuucp 6.14 / source / uuq.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-08-02  |  7.7 KB  |  369 lines  |  [TEXT/KAHL]
  1. #ifndef lint
  2. static char sccsid[] = "@(#)uuq.c    1.4 (Berkeley/gnuucp) 9/29/87";
  3. #endif
  4.  
  5. /*
  6.  * uuq - looks at uucp queues
  7.  *
  8.  * Lou Salkind
  9.  * New York University
  10.  *
  11.  */
  12.  
  13. #include "includes.h"
  14. #include "uucp.h"
  15. #include "sysdep.h"
  16.  
  17. #define    NOSYS        (struct sys *)0
  18.  
  19. #define W_TYPE        wrkvec[0]
  20. #define W_FILE1        wrkvec[1]
  21. #define W_FILE2        wrkvec[2]
  22. #define W_USER        wrkvec[3]
  23. #define W_OPTNS        wrkvec[4]
  24. #define W_DFILE        wrkvec[5]
  25. #define W_MODE        wrkvec[6]
  26. #define WSUFSIZE 5    /* work file name suffix size */
  27.  
  28. struct sys {
  29.     char    s_name[8];
  30.     int    s_njobs;
  31.     off_t    s_bytes;
  32.     struct job    *s_jobp;
  33.     struct sys    *s_sysp;
  34. };
  35.  
  36. struct job {
  37.     int    j_files;
  38.     int    j_flags;
  39.     char    j_jobno[WSUFSIZE];
  40.     char    j_user[22];
  41.     char    j_fname[128];
  42.     char    j_grade;
  43.     off_t    j_bytes;
  44.     time_t    j_date;
  45.     struct job    *j_jobp;
  46. };
  47.  
  48. struct sys *syshead;
  49. struct sys *getsys();
  50. int jcompare();
  51. char *sysname;
  52. char *user;
  53. char *rmjob;
  54. int hflag;
  55. int lflag;
  56.  
  57. #ifndef MAC
  58. char *malloc(), *calloc();
  59. float atof();
  60. #endif
  61.  
  62. float baudrate = 1200.;
  63. char Username[BUFSIZ];
  64. char Filename[BUFSIZ];
  65. int Maxulen = 0;
  66. #ifndef MAC
  67. struct timeb Now;
  68. #endif
  69.  
  70. main(argc, argv)
  71. char **argv;
  72. {
  73.     register i;
  74.     register struct sys *sp;
  75.     register struct job *jp;
  76.     struct job **sortjob;
  77.     int nsys;
  78.  
  79.     strcpy(Progname, "uuq");
  80.  
  81.     while (--argc > 0) {
  82.         argv++;
  83.         if (argv[0][0] == '-') switch (argv[0][1]) {
  84.         case 'r':
  85.             Spool = &argv[0][2];
  86.             break;
  87.         case 's':
  88.             sysname = &argv[0][2];
  89.             if (strlen(sysname) > SYSNSIZE)
  90.                 sysname[SYSNSIZE] = '\0';
  91.             break;
  92.         case 'u':
  93.             user = &argv[0][2];
  94.             break;
  95.         case 'd':
  96.             setuid(getuid());    /* FIXME, system dep. */
  97.             rmjob = &argv[0][2];
  98.             break;
  99.         case 'b':
  100.             baudrate = atof(&argv[0][2]);
  101.             break;
  102.         case 'h':
  103.             hflag++;
  104.             break;
  105.         case 'l':
  106.             lflag++;
  107.             break;
  108.         case 'x':
  109.             debug = atoi(&argv[0][2]);
  110.             break;
  111.         case 'C':
  112.             uuControl = &argv[0][2];
  113.         default:
  114.             fprintf(stderr,
  115.     "usage: uuq [-l] [-h] [-ssystem] [-uuser] [-djobno] [-rspool] [-bbaudrate]\n");
  116.             exit(0);
  117.         }
  118.     }
  119.  
  120.     read_params(uuControl);    /* Find out all sorts of good stuff */
  121.     chdir(Spool);
  122.     baudrate *= 0.7;    /* reduce speed because of protocol overhead */
  123.     baudrate *= 6.;     /* convert to chars/minute (60/10) */
  124.     gather();
  125.     nsys = 0;
  126.     for (sp = syshead; sp; sp = sp->s_sysp) {
  127.         if (sp->s_njobs == 0)
  128.             continue;
  129.         if (!hflag && nsys++ > 0)
  130.             putchar('\n');
  131.         printf("%s: %d %s", sp->s_name,
  132.             sp->s_njobs, sp->s_njobs > 1 ? "jobs" : "job");
  133.         if (lflag) {
  134.             float minutes;
  135.             int hours;
  136.             /* The 80 * njobs is because of the uucp handshaking */
  137.             minutes = (float)(sp->s_bytes + 80 * sp->s_njobs)/baudrate;
  138.             hours = minutes/60;
  139.             printf(", %ld bytes, ", sp->s_bytes);
  140.             if (minutes > 60){
  141.                 printf("%d hour%s, ",hours,
  142.                     hours > 1 ? "s": "");
  143.                 minutes -= 60 * hours;
  144.             }
  145.             printf("%3.1f minutes (@ effective baudrate of %d)",
  146.                 minutes,(int)baudrate/6);
  147.         }
  148.         putchar('\n');
  149.         if (hflag)
  150.             continue;
  151.         /* sort them babies! */
  152.         sortjob = (struct job **)calloc(sp->s_njobs, sizeof (struct job *));
  153.         for (i=0, jp=sp->s_jobp; i < sp->s_njobs; i++, jp=jp->j_jobp)
  154.             sortjob[i] = jp;
  155.         qsort(sortjob, sp->s_njobs, sizeof (struct job *), jcompare);
  156.         for (i = 0; i < sp->s_njobs; i++) {
  157.             jp = sortjob[i];
  158.             if (lflag) {
  159.                 printf("%s %2d %-*s%7ld%5.1f %-12.12s %c %.*s\n",
  160.     jp->j_jobno, jp->j_files, Maxulen, jp->j_user, jp->j_bytes, jp->j_bytes/baudrate,
  161.     ctime(&jp->j_date) + 4, jp->j_flags, sizeof (jp->j_fname), jp->j_fname
  162.                 );
  163.             } else {
  164.                 printf("%s", jp->j_jobno);
  165.                 putchar((i+1)%10 ? '\t' : '\n');
  166.             }
  167.         }
  168.         if (!lflag && (sp->s_njobs%10))
  169.             putchar('\n');
  170.     }
  171.     exit(0);
  172. }
  173.  
  174. jcompare(j1, j2)
  175. struct job **j1, **j2;
  176. {
  177.     int delta;
  178.  
  179.     delta = (*j1)->j_grade - (*j2)->j_grade;
  180.     if (delta)
  181.         return delta;
  182.     return(strcmp((*j1)->j_jobno,(*j2)->j_jobno));
  183. }
  184.  
  185. /*
  186.  * Get all the command file names
  187.  */
  188. gather()
  189. {
  190.     char *d;
  191.  
  192.     /*
  193.      * Find all the spool files in the spooling directory
  194.      */
  195.     if (!work_scan("", "C"))
  196.         return;
  197.  
  198.     for (;;) {
  199.         if ((d = work_next()) == NULL)
  200.             break;
  201.         if (analjob(d) < 0) {
  202.             fprintf(stderr, "out of memory\n");
  203.             break;
  204.         }
  205.     }
  206. }
  207.  
  208. /*
  209.  * analjob does the grunge work of verifying jobs
  210.  */
  211. analjob(filename)
  212. char *filename;
  213. {
  214.     struct job *jp;
  215.     struct sys *sp;
  216.     char sbuf[NAMESIZE+1], str[256], nbuf[256];
  217.     char  *jptr, *wrkvec[20];
  218.     char grade;
  219.     FILE *fp, *df;
  220.     struct stat statb;
  221.     int files, gotname, i;
  222.     off_t bytes;
  223.  
  224.     strncpy(sbuf, filename, NAMESIZE);
  225.     sbuf[NAMESIZE] = '\0';
  226.     jptr = sbuf + strlen(sbuf) - WSUFSIZE;
  227.     grade = *jptr;
  228.     *jptr++ = 0;
  229.     /*
  230.      * sbuf+2 now points to sysname name (null terminated)
  231.      * jptr now points to job number (null terminated)
  232.      */
  233.     if (rmjob) {
  234.         if (strcmp(rmjob, jptr))
  235.             return(0);
  236.     } else {
  237.         if ((sp = getsys(sbuf+2)) == NOSYS)
  238.             return(0);
  239.         if (!lflag) {
  240.             /* SHOULD USE A SMALLER STRUCTURE HERE */
  241.             jp = (struct job *)malloc(sizeof(struct job));
  242.             if (jp == (struct job *)0)
  243.                 return(-1);
  244.             strcpy(jp->j_jobno, jptr);
  245.             jp->j_jobp = sp->s_jobp;
  246.             jp->j_grade = grade;
  247.             sp->s_jobp = jp;
  248.             sp->s_njobs++;
  249.             return(1);
  250.         }
  251.     }
  252.     if ((fp = fopen(munge_filename(filename), "r")) == NULL) {
  253.         perror(munge_filename(filename));
  254.         return(0);
  255.     }
  256.     files = 0;
  257.     bytes = 0;
  258.     gotname = 0;
  259.     while (fgets(str, sizeof str, fp)) {
  260.         if (getargs(str, wrkvec, 20) <= 0)
  261.             continue;
  262.         if (rmjob) {
  263.             if (W_TYPE[0] == 'S' && !index(W_OPTNS, 'c')) {
  264.                 remove(munge_filename(W_DFILE));
  265.                 fprintf(stderr, "Removing data file %s\n", W_DFILE);
  266.             }
  267.             continue;
  268.         }
  269.         if (user && (W_TYPE[0] == 'X' || !prefix(user, W_USER))) {
  270.             fclose(fp);
  271.             return(0);
  272.         }
  273.         files++;
  274.         if (W_TYPE[0] == 'S') {
  275.             if (strcmp(W_DFILE, "D.0") &&
  276.                 stat(munge_filename(W_DFILE), &statb) >= 0)
  277.                 bytes += statb.st_size;
  278.             else if (stat(munge_filename(W_FILE1), &statb) >= 0)
  279.                 bytes += statb.st_size;
  280.         }
  281.         /* amusing heuristic */
  282. #define    isXfile(s)    (s[0]=='D' && s[strlen(s)-WSUFSIZE]=='X')
  283.         if (gotname == 0 && isXfile(W_FILE1)) {
  284.             if ((df = fopen(munge_filename(W_FILE1), "r")) == NULL)
  285.                 continue;
  286.             while (fgets(nbuf, sizeof nbuf, df)) {
  287.                 nbuf[strlen(nbuf) - 1] = '\0';
  288.                 if (nbuf[0] == 'C' && nbuf[1] == ' ') {
  289.                     strcpy(Filename, nbuf+2);
  290.                     gotname++;
  291.                 } else if (nbuf[0] == 'R' && nbuf[1] == ' ') {
  292.                     register char *p, *q, *r;
  293.                     r = q = p = nbuf+2;
  294.                     do {
  295.                         if (*p == '!' || *p == '@'){
  296.                             r = q;
  297.                             q = p+1;
  298.                         }
  299.                     } while (*p++);
  300.  
  301.                     strcpy(Username, r);
  302.                     W_USER = Username;
  303.                 }
  304.             }
  305.             fclose(df);
  306.         }
  307.     }
  308.     fclose(fp);
  309.     if (rmjob) {
  310.         remove(munge_filename(filename));
  311.         fprintf(stderr, "Removing command file %s\n", filename);
  312.         exit(0);
  313.     }
  314.     if (files == 0) {
  315.         static char *wtype = "X";
  316.         static char *wfile = "no commands (forced poll?)";
  317.         W_TYPE = wtype;
  318.         W_FILE1 = wfile;
  319.     }
  320.     jp = (struct job *)malloc(sizeof(struct job));
  321.     if (jp == (struct job *)0)
  322.         return(-1);
  323.     strcpy(jp->j_jobno, jptr);
  324.     jp->j_files = files;
  325.     jp->j_bytes = bytes;
  326.     jp->j_grade = grade;
  327.     jp->j_flags = W_TYPE[0];
  328.     strncpy(jp->j_user, W_TYPE[0]=='X' ? "---" : W_USER, 20 );
  329.     jp->j_user[20] = '\0';
  330.     i = strlen(jp->j_user);
  331.     if (i > Maxulen)
  332.         Maxulen = i;
  333.     /* SHOULD ADD ALL INFORMATION IN THE WHILE LOOP */
  334.     if (gotname)
  335.         strncpy(jp->j_fname, Filename, sizeof jp->j_fname);
  336.     else
  337.         strncpy(jp->j_fname, W_FILE1, sizeof jp->j_fname);
  338.     stat(munge_filename(filename), &statb);
  339.     jp->j_date = statb.st_mtime;
  340.     jp->j_jobp = sp->s_jobp;
  341.     sp->s_jobp = jp;
  342.     sp->s_njobs++;
  343.     sp->s_bytes += jp->j_bytes;
  344.     return(1);
  345. }
  346.  
  347. struct sys *
  348. getsys(s)
  349. register char *s;
  350. {
  351.     register struct sys *sp;
  352.  
  353.     for (sp = syshead; sp; sp = sp->s_sysp)
  354.         if (strcmp(s, sp->s_name) == 0)
  355.             return(sp);
  356.     if (sysname && !prefix(sysname, s))
  357.         return(NOSYS);
  358.     sp = (struct sys *)malloc(sizeof(struct sys));
  359.     if (sp == NOSYS)
  360.         return(NOSYS);
  361.     strcpy(sp->s_name, s);
  362.     sp->s_njobs = 0;
  363.     sp->s_jobp = (struct job *)0;
  364.     sp->s_sysp = syshead;
  365.     sp->s_bytes = 0;
  366.     syshead = sp;
  367.     return(sp);
  368. }
  369.